# Node.js
## [Карта специальности инженер-программист](https://youtu.be/SE5aXH-yf0I)
- [00:00:00  Введение](https://youtu.be/SE5aXH-yf0I?t=0)
- [			00:02:21  Что такое программирование?  ](https://youtu.be/SE5aXH-yf0I?t=141)
- [			00:05:55  Связанные понятия    ](https://youtu.be/SE5aXH-yf0I?t=355)
- [			00:06:43  Основы программной инженерии   ](https://youtu.be/SE5aXH-yf0I?t=403)
- [			00:11:42  Предсказуемые вычисления      ](https://youtu.be/SE5aXH-yf0I?t=702)
- [			00:14:36  Моделирование](https://youtu.be/SE5aXH-yf0I?t=876)
- [			00:14:52  Классификация моделей   ](https://youtu.be/SE5aXH-yf0I?t=892)
- [			00:17:33  Схемы моделирования   ](https://youtu.be/SE5aXH-yf0I?t=1053)
- [			00:22:23  Парадигмы программирования ](https://youtu.be/SE5aXH-yf0I?t=1343)
- [			00:23:16  Императивное и функциональное программирование   ](https://youtu.be/SE5aXH-yf0I?t=1396)
- [			00:28:25  Неструктурное программирование    ](https://youtu.be/SE5aXH-yf0I?t=1705)
- [			00:30:01  Структурное программирование   ](https://youtu.be/SE5aXH-yf0I?t=1801)
- [			00:30:46  Процедурное программирование ](https://youtu.be/SE5aXH-yf0I?t=1846)
- [			00:31:18  Объектно-ориетированное программирование    ](https://youtu.be/SE5aXH-yf0I?t=1878)
- [			00:31:48  Прототипно-ориетированное программирование ](https://youtu.be/SE5aXH-yf0I?t=1908)
- [			00:32:14  Функциональное программирование  ](https://youtu.be/SE5aXH-yf0I?t=1934)
- [			00:32:48  Узконаправленное программирование](https://youtu.be/SE5aXH-yf0I?t=1968)
- [			00:33:44  Техники и технологии](https://youtu.be/SE5aXH-yf0I?t=2024)
- [			00:36:55  Реактивное программирование и Событийно-ориентированное](https://youtu.be/SE5aXH-yf0I?t=2215)
- [			00:38:16  Функционально-реактивное программирование    ](https://youtu.be/SE5aXH-yf0I?t=2296)
- [			00:38:39  Модель акторов](https://youtu.be/SE5aXH-yf0I?t=2319)
- [			00:39:49  Метапрограммирование ](https://youtu.be/SE5aXH-yf0I?t=2389)
- [			00:43:09  Системное и прикладное программирование](https://youtu.be/SE5aXH-yf0I?t=2589)
- [			00:44:25  Задачи программной инженерии    ](https://youtu.be/SE5aXH-yf0I?t=2665)
- [			00:50:46  Как преодолеть сложность  ](https://youtu.be/SE5aXH-yf0I?t=3046)
- [			00:52:16  Данные и логика    ](https://youtu.be/SE5aXH-yf0I?t=3136)
- [			00:57:49  Разработка программного обеспечения    ](https://youtu.be/SE5aXH-yf0I?t=3469)
- [			01:04:50  Подход к разработке  ](https://youtu.be/SE5aXH-yf0I?t=3890)
- [			01:06:04  Гибридная разработка ](https://youtu.be/SE5aXH-yf0I?t=3964)
- [			01:07:10  Принцип NIH  ](https://youtu.be/SE5aXH-yf0I?t=4030)
- [			01:09:12  Классификация приложений по месту запуска](https://youtu.be/SE5aXH-yf0I?t=4152)
- [			01:12:17  Схемы и примеры](https://youtu.be/SE5aXH-yf0I?t=4337)
## [Введение в программирование (1 часть)](https://youtu.be/5Gt61EX6HZ4)
- [ВВЕДЕНИЕ](https://youtu.be/5Gt61EX6HZ4?t=0)
- [			0:00:02 лекция о базовых понятиях для начинающих](https://youtu.be/5Gt61EX6HZ4?t=2)
- [			0:01:43 что-то уже знаете / слышали](https://youtu.be/5Gt61EX6HZ4?t=103)
- [			0:04:50 терминология важна](https://youtu.be/5Gt61EX6HZ4?t=290)
- [			ПОНЯТИЯ](https://youtu.be/5Gt61EX6HZ4?t=0)
- [			0:05:45 инструкция или оператор / Statement](https://youtu.be/5Gt61EX6HZ4?t=345)
- [			0:07:23 синтаксис / Syntax](https://youtu.be/5Gt61EX6HZ4?t=443)
- [			0:09:21 почти все группы операторов / Statements](https://youtu.be/5Gt61EX6HZ4?t=561)
- [			0:13:27 операция 0:14:09 команда 0:15:03 директива](https://youtu.be/5Gt61EX6HZ4?t=807)
- [			0:16:59 выражение / Expression](https://youtu.be/5Gt61EX6HZ4?t=1019)
- [			0:20:53 значение / Value](https://youtu.be/5Gt61EX6HZ4?t=1253)
- [			0:22:28 тип / Type](https://youtu.be/5Gt61EX6HZ4?t=1348)
- [			0:27:22 литерал / Literal](https://youtu.be/5Gt61EX6HZ4?t=1642)
- [			0:28:46 скаляр / Scalar, Primitive, Atomic value](https://youtu.be/5Gt61EX6HZ4?t=1726)
- [			0:31:02 ссылка / Reference](https://youtu.be/5Gt61EX6HZ4?t=1862)
- [			0:34:05 идентификатор / Identifier](https://youtu.be/5Gt61EX6HZ4?t=2045)
- [			0:37:31 переменная / Variable](https://youtu.be/5Gt61EX6HZ4?t=2251)
- [			0:40:08 присвоение / Assignment](https://youtu.be/5Gt61EX6HZ4?t=2408)
- [			0:41:29 константа / Constant](https://youtu.be/5Gt61EX6HZ4?t=2489)
- [			0:43:16 структурные типы / Composed types](https://youtu.be/5Gt61EX6HZ4?t=2596)
- [			0:44:03 флаг / Flag 0:45:09 перечисляемый тип](https://youtu.be/5Gt61EX6HZ4?t=2643)
- [			0:46:02 алгоритм / Algorithm](https://youtu.be/5Gt61EX6HZ4?t=2762)
- [			0:47:40 программа / Program](https://youtu.be/5Gt61EX6HZ4?t=2860)
- [			0:49:01 инженерия / Engineering](https://youtu.be/5Gt61EX6HZ4?t=2941)
- [			0:50:42 инженерия программного обеспечения / Software engineering](https://youtu.be/5Gt61EX6HZ4?t=3042)
- [			0:52:03 программирование / Programming](https://youtu.be/5Gt61EX6HZ4?t=3123)
- [			0:53:31 кодирование / Coding](https://youtu.be/5Gt61EX6HZ4?t=3211)
- [			0:54:15 разработка программного обеспечения / Software development](https://youtu.be/5Gt61EX6HZ4?t=3255)
- [			0:58:49 процедура, функция, подпрограмма, метод: различия](https://youtu.be/5Gt61EX6HZ4?t=3529)
- [			0:59:15 блок кода / Block of code](https://youtu.be/5Gt61EX6HZ4?t=3555)
- [			1:01:58 процедура или подпрограмма / Procedure or Subroutine](https://youtu.be/5Gt61EX6HZ4?t=3718)
- [			1:05:18 функция / Function](https://youtu.be/5Gt61EX6HZ4?t=3918)
- [			1:08:06 сигнатура функции / Function signature](https://youtu.be/5Gt61EX6HZ4?t=4086)
- [			1:09:16 метод / Method](https://youtu.be/5Gt61EX6HZ4?t=4156)
- [			1:10:37 цикл / Loop 1:10:52 итерирование 1:11:40 функциональное программирование](https://youtu.be/5Gt61EX6HZ4?t=4237)
- [			1:13:05 условие / Conditional statements / ветвление](https://youtu.be/5Gt61EX6HZ4?t=4385)
- [			1:14:54 парадигма программирования / Programming paradigm](https://youtu.be/5Gt61EX6HZ4?t=4494)
## [Семинар: Обсуждение плана и материалов курса «Основы программирования»](https://youtu.be/bQMTbRWrteU)
- [0:15 - вопрос по операционным системам](https://youtu.be/bQMTbRWrteU?t=15)
- [			3:35 - какой язык посоветуете из функционального программирования](https://youtu.be/bQMTbRWrteU?t=215)
- [			4:40 - время нужное для прохождения курса](https://youtu.be/bQMTbRWrteU?t=280)
- [			7:25 - учебники по JS и туториал](https://youtu.be/bQMTbRWrteU?t=445)
- [			11:00 - экзамены, сертификат для студентов из других стран](https://youtu.be/bQMTbRWrteU?t=660)
- [			12:45 - как будет проходить экзамен](https://youtu.be/bQMTbRWrteU?t=765)
- [			14:55 - сколько времени нужно уделять в неделю или в день](https://youtu.be/bQMTbRWrteU?t=895)
- [			17:35 - куда задавать вопросы](https://youtu.be/bQMTbRWrteU?t=1055)
- [			18:56 - структура курса](https://youtu.be/bQMTbRWrteU?t=1136)
- [			22:30 - контроль решения задач](https://youtu.be/bQMTbRWrteU?t=1350)
- [			23:35 - сферы применения Node.js](https://youtu.be/bQMTbRWrteU?t=1415)
- [			24:22 - возможно ли посещать курс лично](https://youtu.be/bQMTbRWrteU?t=1462)
- [			26:23 - актуальность изучения С++ и Rust](https://youtu.be/bQMTbRWrteU?t=1583)
- [			27:48 - стану ли я программистом пройдя курс](https://youtu.be/bQMTbRWrteU?t=1668)
- [			28:10 - какой стандарт JS используется в курсе](https://youtu.be/bQMTbRWrteU?t=1690)
- [			28:35 - откуда начинать курс](https://youtu.be/bQMTbRWrteU?t=1715)
- [			29:20 - как посещать старшую группу](https://youtu.be/bQMTbRWrteU?t=1760)
- [			31:45 - об основах вёрстки и популярных фреймворках](https://youtu.be/bQMTbRWrteU?t=1905)
- [			33:03 - обязательно ли использовать фреймворки](https://youtu.be/bQMTbRWrteU?t=1983)
- [			36:15 - почему столь немногим удаётся сдать экзамен](https://youtu.be/bQMTbRWrteU?t=2175)
- [			36:50 - проверка задач для допуска к экзамену и их уровень сложности](https://youtu.be/bQMTbRWrteU?t=2210)
- [			37:55 - теоритические вопросы на экзамене, пример](https://youtu.be/bQMTbRWrteU?t=2275)
- [			39:35 - знание математики](https://youtu.be/bQMTbRWrteU?t=2375)
- [			43:10 - сложные вопросы CS в курсе](https://youtu.be/bQMTbRWrteU?t=2590)
- [			46:00 - как происходит проверка задач для допуска к экзамену](https://youtu.be/bQMTbRWrteU?t=2760)
## [Настройка среды: Node.js, npm, git, eslint](https://youtu.be/hSyA7tcNaCE)
- [](https://youtu.be/hSyA7tcNaCE?t=0)
## [Базовый синтаксис JavaScript](https://youtu.be/xJn3k1f4BiM)
- [00:00:00  Введение](https://youtu.be/xJn3k1f4BiM?t=0)
- [			-------------------------------------  Многоразовые абстракции  (Reusable abstractions)  -----------------------------](https://youtu.be/xJn3k1f4BiM?t=0)
- [			00:03:02  Идентификаторы (identifiers: const, let, arguments, object property)](https://youtu.be/xJn3k1f4BiM?t=182)
- [			00:14:41  Циклы (loops)](https://youtu.be/xJn3k1f4BiM?t=881)
- [			00:22:10  Функции (functions)](https://youtu.be/xJn3k1f4BiM?t=1330)
- [			00:30:35  Объекты (objects)  ](https://youtu.be/xJn3k1f4BiM?t=1835)
- [			------------------------------------------------------------------------------------------------------------------------------------------------------------](https://youtu.be/xJn3k1f4BiM?t=0)
- [			00:33:34  Итерирование  по массиву ( for ( ... of  ... {  } )](https://youtu.be/xJn3k1f4BiM?t=2014)
- [			00:39:01  Итерирование  по объекту  ( for ( ... in  ... {  } )](https://youtu.be/xJn3k1f4BiM?t=2341)
- [			00:42:28  Синтаксис простого  кода](https://youtu.be/xJn3k1f4BiM?t=2548)
- [			00:55:21  Синтаксис функции](https://youtu.be/xJn3k1f4BiM?t=3321)
- [			01:05:38  Синтаксис класса](https://youtu.be/xJn3k1f4BiM?t=3938)
- [			01:09:10  Синтаксис расширения класса с помощью функции](https://youtu.be/xJn3k1f4BiM?t=4150)
- [			01:14:59  Идентификаторы в виде символов unicode](https://youtu.be/xJn3k1f4BiM?t=4499)
- [			01:17:15  Синтаксис комментариев](https://youtu.be/xJn3k1f4BiM?t=4635)
- [			01:18:13  Способы объявления переменных ](https://youtu.be/xJn3k1f4BiM?t=4693)
- [			01:18:24  Скалярные типы переменных (string, number, boolean)](https://youtu.be/xJn3k1f4BiM?t=4704)
- [			01:19:12  Структурные/ссылочные типы переменных (function, array, object)](https://youtu.be/xJn3k1f4BiM?t=4752)
## [Базовый синтаксис JavaScript, продолжение](https://youtu.be/qa-XleqA0JU)
- [---------------------------------------------------------- Базовый обзор типов данных -----------------------------------------------](https://youtu.be/qa-XleqA0JU?t=0)
- [			00:01:34  Number (integer / float)](https://youtu.be/qa-XleqA0JU?t=94)
- [			00:02:11  String ](https://youtu.be/qa-XleqA0JU?t=131)
- [			00:02:15  Boolean](https://youtu.be/qa-XleqA0JU?t=135)
- [			00:02:16  Object](https://youtu.be/qa-XleqA0JU?t=136)
- [			00:03:08  Array](https://youtu.be/qa-XleqA0JU?t=188)
- [			00:04:20  Метод array.push](https://youtu.be/qa-XleqA0JU?t=260)
- [			00:04:31  Метод array.unshift](https://youtu.be/qa-XleqA0JU?t=271)
- [			00:04:50  Метод array.shift](https://youtu.be/qa-XleqA0JU?t=290)
- [			00:05:17  Метод array.pop](https://youtu.be/qa-XleqA0JU?t=317)
- [			00:05:55  Оператор typeof](https://youtu.be/qa-XleqA0JU?t=355)
- [			00:08:33  Метод Array.isArray](https://youtu.be/qa-XleqA0JU?t=513)
- [			00:10:06  Оператор instanceof](https://youtu.be/qa-XleqA0JU?t=606)
- [			00:10:48  Undefined](https://youtu.be/qa-XleqA0JU?t=648)
- [			00:11:12  Null](https://youtu.be/qa-XleqA0JU?t=672)
- [			00:11:55  NaN](https://youtu.be/qa-XleqA0JU?t=715)
- [			00:14:18  Infinity](https://youtu.be/qa-XleqA0JU?t=858)
- [			---------------------------------------------------------------------------------------------------------------------------------------------------------------](https://youtu.be/qa-XleqA0JU?t=0)
- [			00:14:48  Тернарный оператор](https://youtu.be/qa-XleqA0JU?t=888)
- [			00:16:15  Функция paseInt](https://youtu.be/qa-XleqA0JU?t=975)
- [			00:24:23  Функция paseFloat](https://youtu.be/qa-XleqA0JU?t=1463)
- [			00:27:15  Удаление переменных ](https://youtu.be/qa-XleqA0JU?t=1635)
- [			00:33:25  Побитовые операторы (Bitwise operators)](https://youtu.be/qa-XleqA0JU?t=2005)
- [			00:34:38  Побитовые операции](https://youtu.be/qa-XleqA0JU?t=2078)
- [			00:44:30  BigInt](https://youtu.be/qa-XleqA0JU?t=2670)
- [			00:56:30  Операторы сравнения ](https://youtu.be/qa-XleqA0JU?t=3390)
- [			01:01:20  Очередность операторов (Operator precedence)](https://youtu.be/qa-XleqA0JU?t=3680)
- [			01:13:25  Оператор Switch](https://youtu.be/qa-XleqA0JU?t=4405)
## [Семинар: Базовый синтаксис языка JavaScript](https://youtu.be/PGqjTXQe_qw)
- [](https://youtu.be/PGqjTXQe_qw?t=0)
## [Семинар: автоматическая проверка лабораторных работ](https://youtu.be/M4KpG0LEAyA)
- [](https://youtu.be/M4KpG0LEAyA?t=0)
## [Введение в программирование (2 часть)](https://youtu.be/PzlLXQ3RaDs)
- [0:00:01 введение](https://youtu.be/PzlLXQ3RaDs?t=1)
- [			ПОНЯТИЯ](https://youtu.be/PzlLXQ3RaDs?t=0)
- [			0:01:45 процедура или подпрограмма / Procedure or Subroutine](https://youtu.be/PzlLXQ3RaDs?t=105)
- [			0:06:05 функция / Function](https://youtu.be/PzlLXQ3RaDs?t=365)
- [			0:09:27 стек вызовов / Call Stack 0:18:26 Mixed Solution 0:21:42 принцип LIFO](https://youtu.be/PzlLXQ3RaDs?t=567)
- [			0:22:09 куча и стек / Heap and Stack](https://youtu.be/PzlLXQ3RaDs?t=1329)
- [			0:25:55 рекурсия / Recursion](https://youtu.be/PzlLXQ3RaDs?t=1555)
- [			0:27:15 коллекция / Collection](https://youtu.be/PzlLXQ3RaDs?t=1635)
- [			0:27:51 массив / Array](https://youtu.be/PzlLXQ3RaDs?t=1671)
- [			0:28:18 отладка / Debug](https://youtu.be/PzlLXQ3RaDs?t=1698)
- [			0:28:23 компонент / Component](https://youtu.be/PzlLXQ3RaDs?t=1703)
- [			0:29:37 модуль / Module 0:30:16 модульность / Modularity 0:33:52 ограничения 0:31:50 заглушки / Stubs](https://youtu.be/PzlLXQ3RaDs?t=1777)
- [			0:36:19 библиотека / Library](https://youtu.be/PzlLXQ3RaDs?t=2179)
- [			0:37:13 импорт и экспорт идентификаторов / Import and Export Identifiers 0:41:30 новый синтаксис](https://youtu.be/PzlLXQ3RaDs?t=2233)
- [			0:45:22 объект или экземпляр / Object or Instance 0:47:08 2 способа задания Instance](https://youtu.be/PzlLXQ3RaDs?t=2722)
- [			0:47:47 класс / Class 0:49:16 примеры](https://youtu.be/PzlLXQ3RaDs?t=2867)
- [			0:51:30 инстанциирование / Instantiation 0:52:59 примеры](https://youtu.be/PzlLXQ3RaDs?t=3090)
- [			0:54:59 область видимости / Scope](https://youtu.be/PzlLXQ3RaDs?t=3299)
- [			0:57:05 лексический(ое) контекст (окружение) / Lexical environment](https://youtu.be/PzlLXQ3RaDs?t=3425)
- [			0:58:19 объектный контекст функции / Object context: this](https://youtu.be/PzlLXQ3RaDs?t=3499)
- [			1:00:33 глобальный контекст / Global context](https://youtu.be/PzlLXQ3RaDs?t=3633)
- [			ВОПРОСЫ-ОТВЕТЫ](https://youtu.be/PzlLXQ3RaDs?t=0)
- [			1:04:35 монады](https://youtu.be/PzlLXQ3RaDs?t=3875)
- [			1:09:00 парадигмы программирования](https://youtu.be/PzlLXQ3RaDs?t=4140)
- [			1:12:05 лямбда-функция](https://youtu.be/PzlLXQ3RaDs?t=4325)
- [			1:12:28 фрейм](https://youtu.be/PzlLXQ3RaDs?t=4348)
- [			1:14:46 строка в свойстве объекта](https://youtu.be/PzlLXQ3RaDs?t=4486)
- [			1:16:21 класс и объект](https://youtu.be/PzlLXQ3RaDs?t=4581)
- [			1:16:47 класс и прототип 1:17:37 аллокирование значений в куче и стеке](https://youtu.be/PzlLXQ3RaDs?t=4607)
- [			1:18:43 сборщик мусора](https://youtu.be/PzlLXQ3RaDs?t=4723)
- [			1:20:29 терминология на английском и русском](https://youtu.be/PzlLXQ3RaDs?t=4829)
## [Функции, лямбды (стрелочные функции), контексты, замыкания в JavaScript](https://youtu.be/pn5myCmpV2U)
- [00:00:00  Введение ](https://youtu.be/pn5myCmpV2U?t=0)
- [			-----------------------------------------------  Способы определения функций  ---------------------------------------------------](https://youtu.be/pn5myCmpV2U?t=0)
- [			00:11:22  Функция объявление (Declaration)](https://youtu.be/pn5myCmpV2U?t=682)
- [			00:12:46  Функция выражение (Expression)](https://youtu.be/pn5myCmpV2U?t=766)
- [			00:16:07  Лямбда-выражение (Lambda expression) или функция-стрелка (Arrow function) ](https://youtu.be/pn5myCmpV2U?t=967)
- [			00:16:43  Лямбда-функция (Lambda function) ](https://youtu.be/pn5myCmpV2U?t=1003)
- [			------------------------------------------------------------------------------------------------------------------------------------------------------------](https://youtu.be/pn5myCmpV2U?t=0)
- [			00:18:45  Область видимости (Scope)](https://youtu.be/pn5myCmpV2U?t=1125)
- [			00:25:00  Функции, как абстракции](https://youtu.be/pn5myCmpV2U?t=1500)
- [			00:26:43  Методы функции  (name, length, toString( ) )](https://youtu.be/pn5myCmpV2U?t=1603)
- [			00:31:26  Значения по умолчанию у функции ](https://youtu.be/pn5myCmpV2U?t=1886)
- [			00:36:46  Rest-оператор (...args)](https://youtu.be/pn5myCmpV2U?t=2206)
- [			00:41:49  Способ определения функции, через new Function](https://youtu.be/pn5myCmpV2U?t=2509)
- [			00:44:46  Функции внутри объекта](https://youtu.be/pn5myCmpV2U?t=2686)
- [			00:50:42  Обращение к полям объекта из привязанной функции, через this](https://youtu.be/pn5myCmpV2U?t=3042)
- [			00:55:24  История синтаксиса создания контекстов, через самовызывающиеся функции ( IIFE)](https://youtu.be/pn5myCmpV2U?t=3324)
- [			00:58:30  Методы функции, наследуемой от объекта  (call, apply)](https://youtu.be/pn5myCmpV2U?t=3510)
- [			01:00:53  Комментирование функций](https://youtu.be/pn5myCmpV2U?t=3653)
- [			01:01:27  Задание декомпозиции  функции](https://youtu.be/pn5myCmpV2U?t=3687)
- [			01:04:24  Замыкание: context   ](https://youtu.be/pn5myCmpV2U?t=3864)
- [			01:08:41  Замыкание: chainning   ](https://youtu.be/pn5myCmpV2U?t=4121)
- [			01:11:55  Замыкание: summator  ](https://youtu.be/pn5myCmpV2U?t=4315)
- [			01:14:16  Замыкание: recursion](https://youtu.be/pn5myCmpV2U?t=4456)
## [Массивы, объекты, классы, прототипы в JavaScript](https://youtu.be/VBMGnAPfmsY)
- [00:00:00  Объекты](https://youtu.be/VBMGnAPfmsY?t=0)
- [			00:11:01  Массивы](https://youtu.be/VBMGnAPfmsY?t=661)
- [			00:13:29  Cериализация объекта ](https://youtu.be/VBMGnAPfmsY?t=809)
- [			00:15:46  Cериализация массива ](https://youtu.be/VBMGnAPfmsY?t=946)
- [			00:19:20  Методы array](https://youtu.be/VBMGnAPfmsY?t=1160)
- [			00:20:22  Циклы ](https://youtu.be/VBMGnAPfmsY?t=1222)
- [			00:21:16  Цикл  for-in-object  ](https://youtu.be/VBMGnAPfmsY?t=1276)
- [			00:22:02  Цикл  for-in-array](https://youtu.be/VBMGnAPfmsY?t=1322)
- [			00:24:10  Цикл  for-of-array  ](https://youtu.be/VBMGnAPfmsY?t=1450)
- [			00:25:05  Метод  array.forEach](https://youtu.be/VBMGnAPfmsY?t=1505)
- [			00:29:10  Метод  array.map](https://youtu.be/VBMGnAPfmsY?t=1750)
- [			00:33:59  Итерация матрицы, через for-of-array ](https://youtu.be/VBMGnAPfmsY?t=2039)
- [			00:38:38  Итерация матрицы, через array.forEach ](https://youtu.be/VBMGnAPfmsY?t=2318)
- [			00:39:22  Итерация матрицы, через for-in-array  ](https://youtu.be/VBMGnAPfmsY?t=2362)
- [			00:39:45  Метод array.reduce](https://youtu.be/VBMGnAPfmsY?t=2385)
- [			00:44:39  Методы объекта](https://youtu.be/VBMGnAPfmsY?t=2679)
- [			00:46:38  Прототип](https://youtu.be/VBMGnAPfmsY?t=2798)
- [			00:53:32  Класс  ](https://youtu.be/VBMGnAPfmsY?t=3212)
- [			00:56:04  Связывание методов с объектом, при помощи  замыкания](https://youtu.be/VBMGnAPfmsY?t=3364)
- [			01:00:08  Связывание методов с объектом, при помощи метода bind](https://youtu.be/VBMGnAPfmsY?t=3608)
- [			01:03:19  Пример абстракции, при помощи замыкания](https://youtu.be/VBMGnAPfmsY?t=3799)
- [			01:11:05  Пример абстракции, при помощи прототипа  ](https://youtu.be/VBMGnAPfmsY?t=4265)
- [			01:12:30  Пример абстракции, при помощи класса   ](https://youtu.be/VBMGnAPfmsY?t=4350)
- [			01:13:08  Наследование через синтаксис прототипов  ](https://youtu.be/VBMGnAPfmsY?t=4388)
- [			01:18:50  Наследование через синтаксис классов  ](https://youtu.be/VBMGnAPfmsY?t=4730)
- [			01:21:05  Связывание объекта с методом класса при помощи  прототипа ](https://youtu.be/VBMGnAPfmsY?t=4865)
- [			01:23:52  Присваивание методов внутри конструктора, при прототипном подходе ](https://youtu.be/VBMGnAPfmsY?t=5032)
- [			01:25:10  Get/Set класса  ](https://youtu.be/VBMGnAPfmsY?t=5110)
- [			01:27:00  Пример](https://youtu.be/VBMGnAPfmsY?t=5220)
## [Языки программирования: обзор, сравнение, выбор](https://youtu.be/enHA1CRkJe0)
- [0:00:02 обзорная лекция о классификации ЯП](https://youtu.be/enHA1CRkJe0?t=2)
- [			ОСОБЕННОСТИ СИНТАКСИСА И СЕМАНТИКИ](https://youtu.be/enHA1CRkJe0?t=0)
- [			0:00:53 типизация: статическая / динамическая](https://youtu.be/enHA1CRkJe0?t=53)
- [			0:07:37                       сильная / слабая || строгая / нестрогая](https://youtu.be/enHA1CRkJe0?t=457)
- [			0:10:08                       явная / неявная](https://youtu.be/enHA1CRkJe0?t=608)
- [			0:13:58                       утиная 0:18:26 протоколы](https://youtu.be/enHA1CRkJe0?t=838)
- [			УРОВЕНЬ](https://youtu.be/enHA1CRkJe0?t=0)
- [			0:20:36 ниже и ближе к машине / выше и ближе к человеку](https://youtu.be/enHA1CRkJe0?t=1236)
- [			0:32:20 сравнение asm и машинного кода](https://youtu.be/enHA1CRkJe0?t=1940)
- [			0:39:38 сравнение asm и js](https://youtu.be/enHA1CRkJe0?t=2378)
- [			ПОДДЕРЖКА ГРАЖДАН 1 КЛАССА](https://youtu.be/enHA1CRkJe0?t=0)
- [			0:42:47 функции и типы 1 класса](https://youtu.be/enHA1CRkJe0?t=2567)
- [			ДРУГИЕ КРИТЕРИИ](https://youtu.be/enHA1CRkJe0?t=0)
- [			0:44:39 распространённость](https://youtu.be/enHA1CRkJe0?t=2679)
- [			0:45:47 скорость, читаемость](https://youtu.be/enHA1CRkJe0?t=2747)
- [			0:48:21 владение правами / влияние на ЯП](https://youtu.be/enHA1CRkJe0?t=2901)
- [			0:51:13 специализация](https://youtu.be/enHA1CRkJe0?t=3073)
- [			0:53:13 наследственность](https://youtu.be/enHA1CRkJe0?t=3193)
- [			0:56:33 инструментарий](https://youtu.be/enHA1CRkJe0?t=3393)
- [			0:58:20 поддержка](https://youtu.be/enHA1CRkJe0?t=3500)
- [			1:02:58 скорость развития](https://youtu.be/enHA1CRkJe0?t=3778)
- [			СФЕРА ПРИМЕНЕНИЯ](https://youtu.be/enHA1CRkJe0?t=0)
- [			1:04:12 системное программирование](https://youtu.be/enHA1CRkJe0?t=3852)
- [			1:05:51 оконные приложения](https://youtu.be/enHA1CRkJe0?t=3951)
- [			1:06:27 встраиваемые системы и автоматизация](https://youtu.be/enHA1CRkJe0?t=3987)
- [			1:07:02 базы данных](https://youtu.be/enHA1CRkJe0?t=4022)
- [			1:07:45 сетевые сервера](https://youtu.be/enHA1CRkJe0?t=4065)
- [			1:09:03 вычисления](https://youtu.be/enHA1CRkJe0?t=4143)
- [			1:10:45 ИИ](https://youtu.be/enHA1CRkJe0?t=4245)
- [			1:11:52 параллельные вычисления, веб](https://youtu.be/enHA1CRkJe0?t=4312)
- [			1:12:38 скрипты](https://youtu.be/enHA1CRkJe0?t=4358)
- [			1:13:36 тестирование](https://youtu.be/enHA1CRkJe0?t=4416)
- [			1:14:20 мобильные платформы](https://youtu.be/enHA1CRkJe0?t=4460)
- [			1:16:10 игры, графика](https://youtu.be/enHA1CRkJe0?t=4570)
## [JavaScript: Ответы на вопросы](https://youtu.be/wqkQ6eslyzY)
- [0:00:02 введение](https://youtu.be/wqkQ6eslyzY?t=2)
- [			0:00:41 разделение ЯП по модели работы с памятью](https://youtu.be/wqkQ6eslyzY?t=41)
- [			ВОПРОСЫ](https://youtu.be/wqkQ6eslyzY?t=0)
- [			0:08:32 почему надо использовать const, реже let и избегать var](https://youtu.be/wqkQ6eslyzY?t=512)
- [			0:17:43 + и - утиной типизации](https://youtu.be/wqkQ6eslyzY?t=1063)
- [			0:30:03 примеры ЯП с разной типизацией](https://youtu.be/wqkQ6eslyzY?t=1803)
- [			0:32:29 чем выше ЯП, тем он медленнее?](https://youtu.be/wqkQ6eslyzY?t=1949)
- [			0:34:15 почему бы js не компилировать напрямую в машинный код](https://youtu.be/wqkQ6eslyzY?t=2055)
- [			0:35:37 скорость и производительность ЯП](https://youtu.be/wqkQ6eslyzY?t=2137)
- [			0:40:47 константы и ключевое слово const](https://youtu.be/wqkQ6eslyzY?t=2447)
- [			0:45:48 зачем учить именно js](https://youtu.be/wqkQ6eslyzY?t=2748)
- [			0:59:28 typescript - js с типами? Развитость инфраструктуры ts](https://youtu.be/wqkQ6eslyzY?t=3568)
## [Частичное применение и каррирование в JavaScript](https://youtu.be/ND8KQ5xjk7o)
- [-----------------------------------------------  Частичное применение ( Partial application ) ---------------------------------------------](https://youtu.be/ND8KQ5xjk7o?t=0)
- [			00:00:00  Замыкание  ](https://youtu.be/ND8KQ5xjk7o?t=0)
- [			00:04:54  Лямбда- функция ](https://youtu.be/ND8KQ5xjk7o?t=294)
- [			00:06:06  Метод  bind  ](https://youtu.be/ND8KQ5xjk7o?t=366)
- [			00:08:30  Абстрагированный пример функции   ](https://youtu.be/ND8KQ5xjk7o?t=510)
- [			00:13:42  Абстрагированный пример функции  (расширение)  ](https://youtu.be/ND8KQ5xjk7o?t=822)
- [			------------------------------------------  Рекурсивное частичное применение ( Currying ) ------------------------------------------](https://youtu.be/ND8KQ5xjk7o?t=0)
- [			00:15:47  Неправильная реализация каррирования  ](https://youtu.be/ND8KQ5xjk7o?t=947)
- [			00:22:22  Правильная реализация каррирования ](https://youtu.be/ND8KQ5xjk7o?t=1342)
- [			00:28:54  Правильная реализация каррирования  (расширение)](https://youtu.be/ND8KQ5xjk7o?t=1734)
- [			-------------------------------  Объединение из нескольких функций одной ( Composition )  --------------------------------](https://youtu.be/ND8KQ5xjk7o?t=0)
- [			00:31:41  Функциональные абстракции (superposition)](https://youtu.be/ND8KQ5xjk7o?t=1901)
- [			00:38:02  Функциональные абстракции, с сохранением выражений (composition)](https://youtu.be/ND8KQ5xjk7o?t=2282)
- [			00:45:05  Композиция с 2 функциями](https://youtu.be/ND8KQ5xjk7o?t=2705)
- [			00:46:05  Композиция с n - функциями, при помощи метода reduce](https://youtu.be/ND8KQ5xjk7o?t=2765)
- [			00:51:25  Композиция с n - функциями, при помощи цикла  ](https://youtu.be/ND8KQ5xjk7o?t=3085)
- [			00:54:29  Композиция с n - функциями, при помощи рекурсии](https://youtu.be/ND8KQ5xjk7o?t=3269)
- [			00:57:40  Композиция асинхронных функций  ](https://youtu.be/ND8KQ5xjk7o?t=3460)
- [			----------------------------------------------------------------------------------------------------------------------------------------------------------------------](https://youtu.be/ND8KQ5xjk7o?t=0)
- [			01:01:27  Обобщение](https://youtu.be/ND8KQ5xjk7o?t=3687)
## [Функции высшего порядка, колбеки, события на JavaScript](https://youtu.be/1vqATwbGHnc)
- [-----------------------------------  Функции высшего порядка (HigherOrderFunctions)----------------------------------](https://youtu.be/1vqATwbGHnc?t=0)
- [			00:00:00  Определение ](https://youtu.be/1vqATwbGHnc?t=0)
- [			00:02:03  Математическая функция ](https://youtu.be/1vqATwbGHnc?t=123)
- [			00:05:57  Функция обратного вызова (callback) ](https://youtu.be/1vqATwbGHnc?t=357)
- [			00:09:33  Замыкание ](https://youtu.be/1vqATwbGHnc?t=573)
- [			00:10:51  Цепочка вызовов  ](https://youtu.be/1vqATwbGHnc?t=651)
- [			00:12:40  Сохранение кэша с помощью замыкания](https://youtu.be/1vqATwbGHnc?t=760)
- [			00:18:29  Добавление функции поведение логирования](https://youtu.be/1vqATwbGHnc?t=1109)
- [			00:21:45  Обобщение ](https://youtu.be/1vqATwbGHnc?t=1305)
- [			---------------------------------- Применение функций высшего порядка  ---------------------------------------------------](https://youtu.be/1vqATwbGHnc?t=0)
- [			00:22:45  Сallback](https://youtu.be/1vqATwbGHnc?t=1365)
- [			00:25:32  Сallback асинхронной функции считывание файла](https://youtu.be/1vqATwbGHnc?t=1532)
- [			00:28:36  Сallback именованный](https://youtu.be/1vqATwbGHnc?t=1716)
- [			00:33:01  Сallback-timer ](https://youtu.be/1vqATwbGHnc?t=1981)
- [			00:36:20  Сallback-timer-curry](https://youtu.be/1vqATwbGHnc?t=2180)
- [			00:38:59  Listener](https://youtu.be/1vqATwbGHnc?t=2339)
- [			00:41:10  Listener-timer](https://youtu.be/1vqATwbGHnc?t=2470)
- [			00:46:59  Event   ](https://youtu.be/1vqATwbGHnc?t=2819)
- [			00:53:45  Event-imitter  ](https://youtu.be/1vqATwbGHnc?t=3225)
- [			00:57:48  Deferred object (отложенный объект)](https://youtu.be/1vqATwbGHnc?t=3468)
- [			01:01:31  Errors](https://youtu.be/1vqATwbGHnc?t=3691)
## [Работа со строками, шаблонами и юникодом в JavaScript](https://youtu.be/GcopcHQkA8M)
- [00:00:00  Unicode строки](https://youtu.be/GcopcHQkA8M?t=0)
- [			00:12:07  Обычные строки](https://youtu.be/GcopcHQkA8M?t=727)
- [			00:17:03  Методы строки  ](https://youtu.be/GcopcHQkA8M?t=1023)
- [			00:23:09  Модификация строк    ](https://youtu.be/GcopcHQkA8M?t=1389)
- [			00:28:00  Получение подстроки в строке  ](https://youtu.be/GcopcHQkA8M?t=1680)
- [			00:34:45  Polyffill  ](https://youtu.be/GcopcHQkA8M?t=2085)
- [			00:37:54  Методы padEnd и padStart    ](https://youtu.be/GcopcHQkA8M?t=2274)
- [			00:40:45  Добавление функции для шаблонизирующей строки](https://youtu.be/GcopcHQkA8M?t=2445)
- [			00:44:27  Пример  ](https://youtu.be/GcopcHQkA8M?t=2667)
- [			00:48:29  Библиотека  Concolor.js](https://youtu.be/GcopcHQkA8M?t=2909)
## [Регулярные выражения и парсинг в JavaScript](https://youtu.be/-ef2E0ozxao)
- [00:00:00  Введение](https://youtu.be/-ef2E0ozxao?t=0)
- [			00:10:30  Синтаксис регулярных выражений     ](https://youtu.be/-ef2E0ozxao?t=630)
- [			00:12:54  Задание регулярного выражения  ](https://youtu.be/-ef2E0ozxao?t=774)
- [			00:30:38  RegExp  ](https://youtu.be/-ef2E0ozxao?t=1838)
- [			00:38:11  Метод match  ](https://youtu.be/-ef2E0ozxao?t=2291)
- [			00:46:48  Метод split](https://youtu.be/-ef2E0ozxao?t=2808)
- [			00:49:28  Метод replace   ](https://youtu.be/-ef2E0ozxao?t=2968)
- [			00:50:43  Метод replace с аргументом функции  ](https://youtu.be/-ef2E0ozxao?t=3043)
- [			00:53:28  Метод search  ](https://youtu.be/-ef2E0ozxao?t=3208)
- [			00:55:05  Обобщение](https://youtu.be/-ef2E0ozxao?t=3305)
## [Примеси, обертки, декораторы, мемоизация в JavaScript](https://youtu.be/oRQ0kQr1N-U)
- [---------------------------------------------------- Функции-обертки  (Wrappers) ------------------------------------------------](https://youtu.be/oRQ0kQr1N-U?t=0)
- [			00:00:00  Синхронная функция-обертка  ](https://youtu.be/oRQ0kQr1N-U?t=0)
- [			00:02:55  Синхронная универсальная функция-обертка   ](https://youtu.be/oRQ0kQr1N-U?t=175)
- [			00:08:28  Асинхронная универсальная функция-обертка  ](https://youtu.be/oRQ0kQr1N-U?t=508)
- [			00:15:50  Синхронная функция-обертка, которая добавляет поведение (timeout)](https://youtu.be/oRQ0kQr1N-U?t=950)
- [			00:22:45  Асинхронная функция-обертка, которая добавляет поведение (timeout)](https://youtu.be/oRQ0kQr1N-U?t=1365)
- [			00:25:38  Функция-обертка, которая ограничивает вызов функции до одного вызова (once) ](https://youtu.be/oRQ0kQr1N-U?t=1538)
- [			00:27:36  Функция-обертка, которая ограничивает вызов функции до  n-го вызова (limit)](https://youtu.be/oRQ0kQr1N-U?t=1656)
- [			00:29:50  Функция-обертка, которая отменяет вызов функции (cancel)](https://youtu.be/oRQ0kQr1N-U?t=1790)
- [			00:32:29  Функция-обертка с методами timeout, limit, cancel](https://youtu.be/oRQ0kQr1N-U?t=1949)
- [			00:39:03  Функция-обертка с методами timeout, limit, cancel (оптимизированная)](https://youtu.be/oRQ0kQr1N-U?t=2343)
- [			00:42:28  Функция-обертка, которая ограничивает один вызов за 200 мс (throttle)](https://youtu.be/oRQ0kQr1N-U?t=2548)
- [			-----------------------------------------------------------  Примеси (Mixins) ---------------------------------------------------------------](https://youtu.be/oRQ0kQr1N-U?t=0)
- [			00:45:47  Примесь поля через точку  ](https://youtu.be/oRQ0kQr1N-U?t=2747)
- [			00:51:35  Примесь поля через  функцию extend](https://youtu.be/oRQ0kQr1N-U?t=3095)
- [			00:57:35  Примесь поля через object.assign( )](https://youtu.be/oRQ0kQr1N-U?t=3455)
- [			00:59:18  Примесь поведения    ](https://youtu.be/oRQ0kQr1N-U?t=3558)
- [			01:02:23  Примесь изменения класса](https://youtu.be/oRQ0kQr1N-U?t=3743)
- [			---------------------------------------------------  Мемоизация  (Memoization)  ---------------------------------------------------](https://youtu.be/oRQ0kQr1N-U?t=0)
- [			01:06:50  Определение](https://youtu.be/oRQ0kQr1N-U?t=4010)
- [			01:07:30  Реализация простой мемоизации       ](https://youtu.be/oRQ0kQr1N-U?t=4050)
- [			01:14:43  Реализация простой мемоизации с проверкой скорости  ](https://youtu.be/oRQ0kQr1N-U?t=4483)
- [			01:20:43  Удаление накопленного кэша   ](https://youtu.be/oRQ0kQr1N-U?t=4843)
- [			01:25:35  Асинхронная мемоизация ](https://youtu.be/oRQ0kQr1N-U?t=5135)
- [			01:31:10  Преобразование аргументов и ключей в  hash-функцию](https://youtu.be/oRQ0kQr1N-U?t=5470)
- [			01:33:32  Реализация сложной мемоизации](https://youtu.be/oRQ0kQr1N-U?t=5612)
## [Консоль и командная строка в JavaScript и Node.js](https://youtu.be/5aSZyKi5BmE)
- [1:20 console](https://youtu.be/5aSZyKi5BmE?t=80)
- [			16:00 readline](https://youtu.be/5aSZyKi5BmE?t=960)
- [			21:35 cli](https://youtu.be/5aSZyKi5BmE?t=1295)
- [			31:15 делаем красивый login screen](https://youtu.be/5aSZyKi5BmE?t=1875)
## [Чеининг функций и объектов, обработка ошибок в JavaScript](https://youtu.be/PfuEfIiLX34)
- [--------------------------------------------------------------  Чеининг  ----------------------------------------------------------](https://youtu.be/PfuEfIiLX34?t=0)
- [			00:00:00  Введение ](https://youtu.be/PfuEfIiLX34?t=0)
- [			00:01:10  Чеининг через синтаксис вызова функций  ](https://youtu.be/PfuEfIiLX34?t=70)
- [			00:02:12  Prototype  ](https://youtu.be/PfuEfIiLX34?t=132)
- [			00:05:45  Сlass](https://youtu.be/PfuEfIiLX34?t=345)
- [			00:06:11  Functor](https://youtu.be/PfuEfIiLX34?t=371)
- [			00:11:54  Mutable](https://youtu.be/PfuEfIiLX34?t=714)
- [			00:16:34  Iterator](https://youtu.be/PfuEfIiLX34?t=994)
- [			00:26:18  Promise  ](https://youtu.be/PfuEfIiLX34?t=1578)
- [			00:26:35  Test](https://youtu.be/PfuEfIiLX34?t=1595)
- [			00:37:08  Compare ](https://youtu.be/PfuEfIiLX34?t=2228)
- [			00:39:45  Benchmark](https://youtu.be/PfuEfIiLX34?t=2385)
- [			00:40:48  Запуск и анализ тестов ](https://youtu.be/PfuEfIiLX34?t=2448)
- [			----------------------------------------------------  Обработка ошибок --------------------------------------------------](https://youtu.be/PfuEfIiLX34?t=0)
- [			01:03:48  Первый способ возвращение ошибок в синхронном коде   ](https://youtu.be/PfuEfIiLX34?t=3828)
- [			01:09:24  Второй способ возвращение ошибок в синхронном коде ](https://youtu.be/PfuEfIiLX34?t=4164)
- [			01:12:26  Возвращение ошибок в асинхронном коде     ](https://youtu.be/PfuEfIiLX34?t=4346)
- [			01:16:14  Корректное возвращение ошибок      ](https://youtu.be/PfuEfIiLX34?t=4574)
- [			01:20:03  Обработка ошибок c promise  ](https://youtu.be/PfuEfIiLX34?t=4803)
- [			01:23:58  Обработка ошибок c async-await](https://youtu.be/PfuEfIiLX34?t=5038)
## [Таймеры, таймауты, EventEmitter в JavaScript и Node.js](https://youtu.be/LK2jveAnRNg)
- [0:30 callback sync/async](https://youtu.be/LK2jveAnRNg?t=30)
- [			1:35 временная задержка sleep.js](https://youtu.be/LK2jveAnRNg?t=95)
- [			5:35 await-sleep.js](https://youtu.be/LK2jveAnRNg?t=335)
- [			8:40 sleep-then.js](https://youtu.be/LK2jveAnRNg?t=520)
- [			9:30 order.js](https://youtu.be/LK2jveAnRNg?t=570)
- [			18:38 precision.js](https://youtu.be/LK2jveAnRNg?t=1118)
- [			22:13 blocking.js](https://youtu.be/LK2jveAnRNg?t=1333)
- [			22:50 timers.js](https://youtu.be/LK2jveAnRNg?t=1370)
- [			29:35 ref-unref.js](https://youtu.be/LK2jveAnRNg?t=1775)
- [			32:05 enroll.js](https://youtu.be/LK2jveAnRNg?t=1925)
- [			34:57 eventloop.txt](https://youtu.be/LK2jveAnRNg?t=2097)
- [			37:37 eventEmitter](https://youtu.be/LK2jveAnRNg?t=2257)
- [			44:32 simple.js](https://youtu.be/LK2jveAnRNg?t=2672)
- [			47:48 usage.js](https://youtu.be/LK2jveAnRNg?t=2868)
- [			48:30 enhanced.js](https://youtu.be/LK2jveAnRNg?t=2910)
- [			50:18 star-fix.js](https://youtu.be/LK2jveAnRNg?t=3018)
- [			51:10 usage.js](https://youtu.be/LK2jveAnRNg?t=3070)
- [			53:15 closure.js](https://youtu.be/LK2jveAnRNg?t=3195)
- [			54:50 fp.js](https://youtu.be/LK2jveAnRNg?t=3290)
- [			57:10 methods.js](https://youtu.be/LK2jveAnRNg?t=3430)
- [			1:06:35 min.js](https://youtu.be/LK2jveAnRNg?t=3995)
- [			1:12:31 prod.js](https://youtu.be/LK2jveAnRNg?t=4351)
## [Итерирование, циклы и итераторы в JavaScript](https://youtu.be/lq3b5_UGJas)
- [00:00:00  Цикл for](https://youtu.be/lq3b5_UGJas?t=0)
- [			00:02:45  Цикл while](https://youtu.be/lq3b5_UGJas?t=165)
- [			00:03:16  Цикл do while  ](https://youtu.be/lq3b5_UGJas?t=196)
- [			00:03:33  Цикл for in object ](https://youtu.be/lq3b5_UGJas?t=213)
- [			00:04:40  Цикл for in array](https://youtu.be/lq3b5_UGJas?t=280)
- [			00:06:44  Цикл for of](https://youtu.be/lq3b5_UGJas?t=404)
- [			00:08:45  Оператор break](https://youtu.be/lq3b5_UGJas?t=525)
- [			00:10:13  Оператор continue](https://youtu.be/lq3b5_UGJas?t=613)
- [			00:12:12  Итерирование по массиву методом forEach](https://youtu.be/lq3b5_UGJas?t=732)
- [			00:15:10  Итерирование по массиву методом map  ](https://youtu.be/lq3b5_UGJas?t=910)
- [			00:21:23  Итерирование по двухмерному массиву (мatrix)](https://youtu.be/lq3b5_UGJas?t=1283)
- [			00:25:38  Итерирование по двухмерному массиву (мatrix) методом forEach](https://youtu.be/lq3b5_UGJas?t=1538)
- [			00:26:08  Итерирование массива методом reduce](https://youtu.be/lq3b5_UGJas?t=1568)
- [			00:28:49  Итерирование по объекту  ](https://youtu.be/lq3b5_UGJas?t=1729)
- [			00:37:32  Обратный итератор    ](https://youtu.be/lq3b5_UGJas?t=2252)
- [			00:40:42  Асинхронный итератор](https://youtu.be/lq3b5_UGJas?t=2442)
## [Архитектурный подход к программированию](https://youtu.be/d_vyO2CkiOc)
- [00:00:00 Когда нужна архитектура](https://youtu.be/d_vyO2CkiOc?t=0)
- [			00:06:07 Принятие решений](https://youtu.be/d_vyO2CkiOc?t=367)
- [			00:09:58 Типы связывания](https://youtu.be/d_vyO2CkiOc?t=598)
- [			00:20:00 Ошибки](https://youtu.be/d_vyO2CkiOc?t=1200)
- [			00:27:15 Принятие решений](https://youtu.be/d_vyO2CkiOc?t=1635)
- [			00:37:05 Эволюция архитектурных решений](https://youtu.be/d_vyO2CkiOc?t=2225)
- [			00:58:13 Схема современной архитектуры](https://youtu.be/d_vyO2CkiOc?t=3493)
- [			01:01:40 субд в браузере](https://youtu.be/d_vyO2CkiOc?t=3700)
- [			01:05:20 Альтернативные варианты](https://youtu.be/d_vyO2CkiOc?t=3920)
- [			01:12:20 Как на самом деле](https://youtu.be/d_vyO2CkiOc?t=4340)
- [			01:13:45 Архитектура мечты](https://youtu.be/d_vyO2CkiOc?t=4425)
- [			01:16:45 Современные возможности и требования ](https://youtu.be/d_vyO2CkiOc?t=4605)
- [			01:25:20 Топологии](https://youtu.be/d_vyO2CkiOc?t=5120)
- [			01:30:45 Итог](https://youtu.be/d_vyO2CkiOc?t=5445)
## [Функциональное программирование на JavaScript](https://youtu.be/0JxSs_GcvbQ)
- [](https://youtu.be/0JxSs_GcvbQ?t=0)
## [Реактивное программирование на JavaScript](https://youtu.be/7MH8-qQc-48)
- [0:00 введение](https://youtu.be/7MH8-qQc-48?t=0)
- [			3:00 imperative.js](https://youtu.be/7MH8-qQc-48?t=180)
- [			4:00 set-get.js](https://youtu.be/7MH8-qQc-48?t=240)
- [			7:15 proxy.js](https://youtu.be/7MH8-qQc-48?t=435)
- [			23:07 observer.js](https://youtu.be/7MH8-qQc-48?t=1387)
## [Асинхронное программирование на callback`ах в JavaScript](https://youtu.be/z8Hg6zgi3yQ)
- [1:20 пример callback функции](https://youtu.be/z8Hg6zgi3yQ?t=80)
- [			2:40 пример последовательного исполнения callback функций](https://youtu.be/z8Hg6zgi3yQ?t=160)
- [			5:52 пример параллельного исполнения async функций c использованием wrapAsync](https://youtu.be/z8Hg6zgi3yQ?t=352)
- [			15:18 пример последовательного исполнения async функций c использованием wrapAsync](https://youtu.be/z8Hg6zgi3yQ?t=918)
- [			19:05 chain исполнение async функций](https://youtu.be/z8Hg6zgi3yQ?t=1145)
- [			41:16 где можно встретить асинхронные функции](https://youtu.be/z8Hg6zgi3yQ?t=2476)
## [Проекции и отображения наборов данных в JavaScript](https://youtu.be/lwJCq9inky8)
- [00:00:00  Введение ](https://youtu.be/lwJCq9inky8?t=0)
- [			00:01:50  Простая проекция набора данных    ](https://youtu.be/lwJCq9inky8?t=110)
- [			00:09:23  Расширенная проекция набора данных  ](https://youtu.be/lwJCq9inky8?t=563)
- [			00:19:00  Расширенная проекция набора данных с кэшированием списка ключей](https://youtu.be/lwJCq9inky8?t=1140)
- [			00:20:27  Оптимизация проекции набора данных с помощью императивного программирования  ](https://youtu.be/lwJCq9inky8?t=1227)
- [			00:23:11  Линзы из функционального программирования ](https://youtu.be/lwJCq9inky8?t=1391)
- [			00:32:29  Сложная проекция набора данных  ( проекция изнутри и снаружи ) ](https://youtu.be/lwJCq9inky8?t=1949)
- [			00:39:08  Сложная проекция набора данных с помощью декларативного программирования ](https://youtu.be/lwJCq9inky8?t=2348)
- [			00:41:57  Оптимизация сложной проекции  ](https://youtu.be/lwJCq9inky8?t=2517)
- [			00:51:36  Синтаксис фильтрации         ](https://youtu.be/lwJCq9inky8?t=3096)
- [			00:53:25  Вывод      ](https://youtu.be/lwJCq9inky8?t=3205)
- [			00:58:08  Оптимизация](https://youtu.be/lwJCq9inky8?t=3488)
- [			01:00:00  Обобщение](https://youtu.be/lwJCq9inky8?t=3600)
## [Коллекции, множества, хештаблицы в JavaScript](https://youtu.be/hN0wsq5LNOc)
- [------------------------------------------------------- Коллекции (Сollections)  --------------------------------------------------------](https://youtu.be/hN0wsq5LNOc?t=0)
- [			00:00:00  Введение](https://youtu.be/hN0wsq5LNOc?t=0)
- [			00:01:35  Массивы ](https://youtu.be/hN0wsq5LNOc?t=95)
- [			00:01:56  Склеивание массива методом concat  ](https://youtu.be/hN0wsq5LNOc?t=116)
- [			00:02:02  Склеивание массива оператором spread   ](https://youtu.be/hN0wsq5LNOc?t=122)
- [			00:03:17  Объекты   ](https://youtu.be/hN0wsq5LNOc?t=197)
- [			00:03:28  Склеивание объектов методом object.assign ](https://youtu.be/hN0wsq5LNOc?t=208)
- [			00:04:01  Склеивание объектов оператором spread ](https://youtu.be/hN0wsq5LNOc?t=241)
- [			00:04:38  Символический тип  ](https://youtu.be/hN0wsq5LNOc?t=278)
- [			00:06:50  Сохранение коллекции в файл  ](https://youtu.be/hN0wsq5LNOc?t=410)
- [							  Map object](https://youtu.be/hN0wsq5LNOc?t=0)
- [			00:08:45  Использование конструированного map  ](https://youtu.be/hN0wsq5LNOc?t=525)
- [			00:14:29  Использование встроенного map ](https://youtu.be/hN0wsq5LNOc?t=869)
- [			00:15:01  Отличия  конструированного и встроенного map](https://youtu.be/hN0wsq5LNOc?t=901)
- [			00:16:49  Способы итерации по map  ](https://youtu.be/hN0wsq5LNOc?t=1009)
- [			00:18:15  Построение индексов помощью map](https://youtu.be/hN0wsq5LNOc?t=1095)
- [			00:23:15  WeakMap](https://youtu.be/hN0wsq5LNOc?t=1395)
- [							  Set object (множества)](https://youtu.be/hN0wsq5LNOc?t=0)
- [			00:27:55  Отдача значения без ключа        ](https://youtu.be/hN0wsq5LNOc?t=1675)
- [			00:29:15  Хранение уникальных значений ](https://youtu.be/hN0wsq5LNOc?t=1755)
- [			00:33:32  Операции со массивами   ](https://youtu.be/hN0wsq5LNOc?t=2012)
- [			00:39:48  Операции над множествами ](https://youtu.be/hN0wsq5LNOc?t=2388)
- [			00:42:32  WeakSet    ](https://youtu.be/hN0wsq5LNOc?t=2552)
- [			00:47:15  Обобщение](https://youtu.be/hN0wsq5LNOc?t=2835)
## [Неблокирующее асинхронное итерирование в JavaScript](https://youtu.be/wYA2cIRYLoA)
- [1:02 блокирующее итерирование по массиву](https://youtu.be/wYA2cIRYLoA?t=62)
- [			3:24 блокирующее итерирование с помощью for await](https://youtu.be/wYA2cIRYLoA?t=204)
- [			4:47 неблокирующее итерирование с помощью setTimeout](https://youtu.be/wYA2cIRYLoA?t=287)
- [			6:45 неблокирующее итерирование с помощью for await](https://youtu.be/wYA2cIRYLoA?t=405)
- [			8:20 неблокирующее итерирование без задержки](https://youtu.be/wYA2cIRYLoA?t=500)
- [			13:00 неблокирующее итерирование без задержки с помощью for await](https://youtu.be/wYA2cIRYLoA?t=780)
- [			19:30 использование асинхронного итерирования для обычных массивов](https://youtu.be/wYA2cIRYLoA?t=1170)
## [Структуры данных: списки, стек, очередь, дэк в JavaScript](https://youtu.be/9KvA4hDDSjk)
- [00:00:00  Идея структуры данных](https://youtu.be/9KvA4hDDSjk?t=0)
- [			Списки ( list )](https://youtu.be/9KvA4hDDSjk?t=0)
- [00:02:27  Списки на прототипах ( абстракция элемента )    ](https://youtu.be/9KvA4hDDSjk?t=147)
- [00:06:23  Списки на объектах   ](https://youtu.be/9KvA4hDDSjk?t=383)
- [00:07:28  Списки на замыканиях](https://youtu.be/9KvA4hDDSjk?t=448)
- [00:10:56  Списки на объектах ( абстракция элемента и списка )   ](https://youtu.be/9KvA4hDDSjk?t=656)
- [00:18:22  Списки на классах](https://youtu.be/9KvA4hDDSjk?t=1102)
- [			Стек  ( stack )](https://youtu.be/9KvA4hDDSjk?t=0)
- [00:21:08  Стек на прототипах ( двух-связанный)](https://youtu.be/9KvA4hDDSjk?t=1268)
- [00:28:17  Стек на классах (односвязный)](https://youtu.be/9KvA4hDDSjk?t=1697)
- [			Очередь  ( queue  )](https://youtu.be/9KvA4hDDSjk?t=0)
- [00:29:55  Очередь](https://youtu.be/9KvA4hDDSjk?t=1795)
- [			Дэк  (double ended queue  )    ](https://youtu.be/9KvA4hDDSjk?t=0)
- [00:34:26  Дэк](https://youtu.be/9KvA4hDDSjk?t=2066)
## [Proxy и Symbol в JavaScript](https://youtu.be/UjZjSDyi9AM)
- [---------------------------------------------------------------------  Proxy  -------------------------------------------------------------------](https://youtu.be/UjZjSDyi9AM?t=0)
- [			00:00:00  Определение Proxy](https://youtu.be/UjZjSDyi9AM?t=0)
- [			00:01:20  Обращение к свойствам объекта, находящегося внутри proxy](https://youtu.be/UjZjSDyi9AM?t=80)
- [			00:04:10  Доступ к состоянию объекта через Getter и Setter ](https://youtu.be/UjZjSDyi9AM?t=250)
- [			00:05:13  Доступ к состоянию объекта через Proxy  ](https://youtu.be/UjZjSDyi9AM?t=313)
- [			00:07:40  Проверка наличие свойств    ](https://youtu.be/UjZjSDyi9AM?t=460)
- [			00:11:22  Удаление свойств](https://youtu.be/UjZjSDyi9AM?t=682)
- [			00:13:26  Обращение к аргументам функции, находящегося внутри proxy    ](https://youtu.be/UjZjSDyi9AM?t=806)
- [			00:15:30  Другие Proxy обработчики (Proxy handler  )](https://youtu.be/UjZjSDyi9AM?t=930)
- [			00:19:00  Proxy.revocable ](https://youtu.be/UjZjSDyi9AM?t=1140)
- [			-----------------------------------------------------------------  Symbol  -------------------------------------------------------------------   ](https://youtu.be/UjZjSDyi9AM?t=0)
- [			00:20:43  Определение Symbol   ](https://youtu.be/UjZjSDyi9AM?t=1243)
- [			00:23:00  Вывод и сравнение Symbol  ](https://youtu.be/UjZjSDyi9AM?t=1380)
- [			00:25:10  Type](https://youtu.be/UjZjSDyi9AM?t=1510)
- [			00:29:51  Symbol.for](https://youtu.be/UjZjSDyi9AM?t=1791)
- [			00:34:45  Symbol.iterator  ](https://youtu.be/UjZjSDyi9AM?t=2085)
- [			00:43:52  Symbol.toPrimitive](https://youtu.be/UjZjSDyi9AM?t=2632)
- [			00:47:00  hideSymbol](https://youtu.be/UjZjSDyi9AM?t=2820)
## [Сериализация и десериализация в JavaScript и Node.js](https://youtu.be/GtKPniOEzh8)
- [00:00:00  Введение ](https://youtu.be/GtKPniOEzh8?t=0)
- [			00:01:50  Виды сериализации ](https://youtu.be/GtKPniOEzh8?t=110)
- [			00:02:45  Сериализатор  console.dir  ](https://youtu.be/GtKPniOEzh8?t=165)
- [			00:03:45  Cериализатор CSV](https://youtu.be/GtKPniOEzh8?t=225)
- [			00:05:42  Сериализатор JSON  ](https://youtu.be/GtKPniOEzh8?t=342)
- [			00:10:00  Сериализатор функции](https://youtu.be/GtKPniOEzh8?t=600)
- [			00:15:25  Сериализатор функции разных типов  (расширяемый)](https://youtu.be/GtKPniOEzh8?t=925)
- [			00:23:06  Десереализация ](https://youtu.be/GtKPniOEzh8?t=1386)
- [			00:25:26  Сериализация объекта в бинарный формат, с помощью библиотеки  v8  ](https://youtu.be/GtKPniOEzh8?t=1526)
- [			00:28:26  Сериализация объекта, с помощью разных библиотек](https://youtu.be/GtKPniOEzh8?t=1706)
## [Асинхронность с библиотекой async.js](https://youtu.be/XQ94wQc-erU)
- [](https://youtu.be/XQ94wQc-erU?t=0)
## [Фабрики и пулы объектов в JavaScript, factorify, poolify](https://youtu.be/Ax_mSvadFp8)
- [00:00:00  Введение ](https://youtu.be/Ax_mSvadFp8?t=0)
- [			00:02:38  Фабрика  ( factory )](https://youtu.be/Ax_mSvadFp8?t=158)
- [			00:05:44  Фабрика прототипов      ](https://youtu.be/Ax_mSvadFp8?t=344)
- [			00:10:48  Фабрика классов   ](https://youtu.be/Ax_mSvadFp8?t=648)
- [			00:12:28  Фабрика функций   ](https://youtu.be/Ax_mSvadFp8?t=748)
- [			00:15:55  Фабричные методы  ](https://youtu.be/Ax_mSvadFp8?t=955)
- [			00:16:55  Превращение функций в фабрику  ( factorify)](https://youtu.be/Ax_mSvadFp8?t=1015)
- [			00:19:44  Пул ( pool )](https://youtu.be/Ax_mSvadFp8?t=1184)
- [			00:23:05  Работа с пулом    ](https://youtu.be/Ax_mSvadFp8?t=1385)
- [			00:23:04  Обобщенный пул](https://youtu.be/Ax_mSvadFp8?t=1384)
- [			00:24:55  Пулифицирование фабрики ( poolify )  ](https://youtu.be/Ax_mSvadFp8?t=1495)
- [			00:28:50  Улучшеная пулифицированная фабрика  ](https://youtu.be/Ax_mSvadFp8?t=1730)
- [			00:32:10  Ассинхронная работа с пулом  ](https://youtu.be/Ax_mSvadFp8?t=1930)
- [			00:45:25  Одновременное использование factorify и poolify ](https://youtu.be/Ax_mSvadFp8?t=2725)
- [			00:51:54  Обобщение](https://youtu.be/Ax_mSvadFp8?t=3114)
## [Подход к изучению программирования (выступление на дне факультета Информатики КПИ 12 декабря 2018)](https://youtu.be/zMU4ir10DMg)
- [00:40  Что нужно знать?](https://youtu.be/zMU4ir10DMg?t=40)
- [			03:41  Откуда брать знания    ](https://youtu.be/zMU4ir10DMg?t=221)
- [			07:39  Проблемы отрасли  ](https://youtu.be/zMU4ir10DMg?t=459)
- [			13:12  Дерево парадигм  ](https://youtu.be/zMU4ir10DMg?t=792)
- [			14:15  Технологии и техники](https://youtu.be/zMU4ir10DMg?t=855)
- [			14:32  Разница парадигм](https://youtu.be/zMU4ir10DMg?t=872)
- [			14:48  Что общего в парадигмах](https://youtu.be/zMU4ir10DMg?t=888)
- [			15:33  Прочие парадигмы и техники](https://youtu.be/zMU4ir10DMg?t=933)
- [			17:46  Мультипарадигменность](https://youtu.be/zMU4ir10DMg?t=1066)
- [			18:46  Метапрограммирование](https://youtu.be/zMU4ir10DMg?t=1126)
- [			19:13  Как не деградировать?](https://youtu.be/zMU4ir10DMg?t=1153)
- [			21:29  Как найти общий язык?  ](https://youtu.be/zMU4ir10DMg?t=1289)
- [			24:31  Задачи программной инженерии](https://youtu.be/zMU4ir10DMg?t=1471)
- [			28:19  Преодоление сложности ](https://youtu.be/zMU4ir10DMg?t=1699)
- [			28:21  Связывание данных и логики](https://youtu.be/zMU4ir10DMg?t=1701)
- [			28:30  Различные концепции  ](https://youtu.be/zMU4ir10DMg?t=1710)
- [			29:40  ВУЗ должен меняться](https://youtu.be/zMU4ir10DMg?t=1780)
- [			33:53  Неспециальные предметы](https://youtu.be/zMU4ir10DMg?t=2033)
- [			35:18  Чего не хватает](https://youtu.be/zMU4ir10DMg?t=2118)
- [			36:57  Проблем много ](https://youtu.be/zMU4ir10DMg?t=2217)
- [			40:20  ВУЗ должен знать](https://youtu.be/zMU4ir10DMg?t=2420)
## [Асинхронность на промисах, Promise, all, then, catch, race](https://youtu.be/RMl4r6s1Y8M)
- [](https://youtu.be/RMl4r6s1Y8M?t=0)
## [Типизированные массивы в JavaScript](https://youtu.be/tTNcqxbxhfY)
- [](https://youtu.be/tTNcqxbxhfY?t=0)
## [Шаблон Singleton (синглтон) в JavaScript](https://youtu.be/qdJ5yikZnfE)
- [00:00:00  Singleton через конструктор прототипа](https://youtu.be/qdJ5yikZnfE?t=0)
- [			00:03:27  Singleton через замыкания  ](https://youtu.be/qdJ5yikZnfE?t=207)
- [			00:06:10  Пример singleton через замыкания ](https://youtu.be/qdJ5yikZnfE?t=370)
- [			00:08:15  Пример singleton через замыкания в функциональном стиле  ](https://youtu.be/qdJ5yikZnfE?t=495)
- [			00:09:23  Пример singleton через замыкания в функциональном стиле  (упрощенный)    ](https://youtu.be/qdJ5yikZnfE?t=563)
- [			00:10:32  Создание singleton в JS](https://youtu.be/qdJ5yikZnfE?t=632)
## [Функциональные объекты, функторы и монады в JavaScript](https://youtu.be/3Z7f0Gi8pxw)
- [00:00:00  Определение функтора  ](https://youtu.be/3Z7f0Gi8pxw?t=0)
- [			00:01:40  Функтор из прототипа     ](https://youtu.be/3Z7f0Gi8pxw?t=100)
- [			00:08:17  Функтор из прототипа (упрощенный)  ](https://youtu.be/3Z7f0Gi8pxw?t=497)
- [			00:09:14  Функтор из замыкания  ](https://youtu.be/3Z7f0Gi8pxw?t=554)
- [			00:11:49  Функтор из замыкания с тернарным оператором](https://youtu.be/3Z7f0Gi8pxw?t=709)
- [			00:12:44  Аппликативный функтор из прототипа  ](https://youtu.be/3Z7f0Gi8pxw?t=764)
- [			00:18:08  Аппликативный функтор из замыкания (монада)](https://youtu.be/3Z7f0Gi8pxw?t=1088)
- [			00:23:11  Пример применения монады     ](https://youtu.be/3Z7f0Gi8pxw?t=1391)
- [			00:28:37  Функциональный объект   ](https://youtu.be/3Z7f0Gi8pxw?t=1717)
- [			00:39:44  Пример применения функционального объекта](https://youtu.be/3Z7f0Gi8pxw?t=2384)
- [			00:45:27  Обобщение](https://youtu.be/3Z7f0Gi8pxw?t=2727)
## [Асинхронные функции, async/await, thenable, обработка ошибок](https://youtu.be/Jdf_tZuJbHI)
- [](https://youtu.be/Jdf_tZuJbHI?t=0)
## [Асинхронные адаптеры: promisify, callbackify, asyncify...](https://youtu.be/76k6_YkYRmU)
- [](https://youtu.be/76k6_YkYRmU?t=0)
## [Асинхронные коллекторы данных](https://youtu.be/tgodt1JL6II)
- [](https://youtu.be/tgodt1JL6II?t=0)
## [Утечки памяти в Node.js и JavaScript, сборка мусора и профилирование](https://youtu.be/0oZa64SB2wM)
- [](https://youtu.be/0oZa64SB2wM?t=0)
## [Рекурсия: косвенная и хвостовая, стек, выход](https://youtu.be/W2skCjIgVKE)
- [00:00  Рекурсивная функция для вычисления глубины стека](https://youtu.be/W2skCjIgVKE?t=0)
- [			03:25  Неявная рекурсия](https://youtu.be/W2skCjIgVKE?t=205)
- [			04:52  Рекурсивная функция для вычисления степени числа](https://youtu.be/W2skCjIgVKE?t=292)
- [			06:12  Рекурсивная функция для вычисления факториала     ](https://youtu.be/W2skCjIgVKE?t=372)
- [			06:29  Рекурсивная функция для вычисления числа Фибоначчи  ](https://youtu.be/W2skCjIgVKE?t=389)
- [			09:27  Рекурсивная функция, как аналог функции reduce     ](https://youtu.be/W2skCjIgVKE?t=567)
- [			12:04  Оптимизация хвостовой рекурсии ](https://youtu.be/W2skCjIgVKE?t=724)
- [			15:41  Оптимизация обычной рекурсивной функции](https://youtu.be/W2skCjIgVKE?t=941)
## [Дженерики и обобщенное программирование](https://youtu.be/r6W2z3DQhoI)
- [](https://youtu.be/r6W2z3DQhoI?t=0)
## [Генераторы и асинхронные генераторы в JavaScript](https://youtu.be/kvNm9D32s8s)
- [00:00 Способы объявления генераторов  ](https://youtu.be/kvNm9D32s8s?t=0)
- [			10:41 Пример генератора с yield  ](https://youtu.be/kvNm9D32s8s?t=641)
- [			15:54 Пример генератора с yield и return  ](https://youtu.be/kvNm9D32s8s?t=954)
- [			18:47 Получение значений из генератора циклом for...of ](https://youtu.be/kvNm9D32s8s?t=1127)
- [			21:04 Получение значений из генератора spead - оператором ](https://youtu.be/kvNm9D32s8s?t=1264)
- [			21:50 Метод next  ](https://youtu.be/kvNm9D32s8s?t=1310)
- [			23:30 Пример генератора с yield *  возвращающего итерируемые объекты ](https://youtu.be/kvNm9D32s8s?t=1410)
- [			25:05 Пример генератора с yield *  возвращающего другие генераторы ](https://youtu.be/kvNm9D32s8s?t=1505)
- [			26:18 Метод return  ](https://youtu.be/kvNm9D32s8s?t=1578)
- [			28:11 Метод throw](https://youtu.be/kvNm9D32s8s?t=1691)
- [			29:05 Обобщение](https://youtu.be/kvNm9D32s8s?t=1745)
## [Итераторы и асинхронные итераторы в JavaScript](https://youtu.be/rBGFlWpVpGs)
- [](https://youtu.be/rBGFlWpVpGs?t=0)
## [Фасад - петтерн для скрытия сложности](https://youtu.be/oJtBO7CystE)
- [](https://youtu.be/oJtBO7CystE?t=0)
## [Адаптер (Adapter) - паттерн достижения совместимости](https://youtu.be/cA65McLQrR8)
- [0:00 введение](https://youtu.be/cA65McLQrR8?t=0)
- [			1:30 adapter на prototype](https://youtu.be/cA65McLQrR8?t=90)
- [			3:57 adapter на class](https://youtu.be/cA65McLQrR8?t=237)
- [			4:23 adapter на function](https://youtu.be/cA65McLQrR8?t=263)
- [			6:15 adapter  на классе-обертке (boxing)](https://youtu.be/cA65McLQrR8?t=375)
- [			7:08 adapter на замыканиях (closure)](https://youtu.be/cA65McLQrR8?t=428)
- [			8:10 adapter на interface](https://youtu.be/cA65McLQrR8?t=490)
- [			13:45 adapter на events](https://youtu.be/cA65McLQrR8?t=825)
- [			16:00 выводы](https://youtu.be/cA65McLQrR8?t=960)
## [Стратегия (Strategy) - выбор взаимозаменяемого поведения](https://youtu.be/hO8VSVv0NqM)
- [0:00 введение](https://youtu.be/hO8VSVv0NqM?t=0)
- [			3:40 strategy на class](https://youtu.be/hO8VSVv0NqM?t=220)
- [			15:04 strategy на prototype](https://youtu.be/hO8VSVv0NqM?t=904)
- [			16:14 strategy на function](https://youtu.be/hO8VSVv0NqM?t=974)
- [			20:22 strategy с примером работы над массивом](https://youtu.be/hO8VSVv0NqM?t=1222)
- [			24:07 обобщение](https://youtu.be/hO8VSVv0NqM?t=1447)
## [Линзы в JavaScript - функциональные аналоги геттера и сеттера](https://youtu.be/IBF5gFU6G-o)
- [](https://youtu.be/IBF5gFU6G-o?t=0)
## [Перечислимый тип (enum) в JavaScript и TypeScript](https://youtu.be/BXiKebOIAGI)
- [](https://youtu.be/BXiKebOIAGI?t=0)
## [Графы и запросы к графовым структурам на JavaScript](https://youtu.be/a0W0T8Yqw3s)
- [](https://youtu.be/a0W0T8Yqw3s?t=0)
## [Паттерн Команда (Command) действие и параметры как объект](https://youtu.be/vER0vYL4hM4)
- [](https://youtu.be/vER0vYL4hM4?t=0)
## [Тестирование: юниттесты с примерами на JavaScript](https://youtu.be/CszugIag2TA)
- [](https://youtu.be/CszugIag2TA?t=0)
## [Инверсия управления и внедрение зависимостей в Node.js](https://youtu.be/Fz86Fdjz-LM)
- [](https://youtu.be/Fz86Fdjz-LM?t=0)
## [Слои, связанность и связность кода в JavaScript](https://youtu.be/A3RpwNlVeyY)
- [](https://youtu.be/A3RpwNlVeyY?t=0)
## [Измерение производительности кода и оптимизация в JavaScript и Node.js](https://youtu.be/sanq2X7Re8o)
- [00:00:00  Введение ](https://youtu.be/sanq2X7Re8o?t=0)
- [			00:05:27  Console.time и console.timeEnd ](https://youtu.be/sanq2X7Re8o?t=327)
- [			00:09:05  New Date( ).getTime( ) ](https://youtu.be/sanq2X7Re8o?t=545)
- [			00:11:15  Process.hrtime( )](https://youtu.be/sanq2X7Re8o?t=675)
- [			00:18:51  Process.hrtime.bigint( ) и движок для benchmark](https://youtu.be/sanq2X7Re8o?t=1131)
- [			00:27:00  Сравнение функций инстанцирования  ](https://youtu.be/sanq2X7Re8o?t=1620)
- [			00:31:06  Алгоритм для сравнения    ](https://youtu.be/sanq2X7Re8o?t=1866)
- [			00:39:36  Работа движка benchmark  ](https://youtu.be/sanq2X7Re8o?t=2376)
- [			00:41:37  Результаты теста](https://youtu.be/sanq2X7Re8o?t=2497)
- [			00:47:33  Сравнение массива и объектов ](https://youtu.be/sanq2X7Re8o?t=2853)
- [			00:54:21  Результаты теста      ](https://youtu.be/sanq2X7Re8o?t=3261)
- [			00:55:00  Сравнение 3 функций range  ](https://youtu.be/sanq2X7Re8o?t=3300)
- [			00:56:34  Результаты теста   ](https://youtu.be/sanq2X7Re8o?t=3394)
- [			00:58:50  Сравнение функций по способу вызова](https://youtu.be/sanq2X7Re8o?t=3530)
- [			00:59:56  Результаты теста](https://youtu.be/sanq2X7Re8o?t=3596)
- [			01:01:34  Сравнение indexOf и includes](https://youtu.be/sanq2X7Re8o?t=3694)
- [			01:01:54  Результаты теста  ](https://youtu.be/sanq2X7Re8o?t=3714)
- [			01:03:23  Сравнение объявления переменной до и после цикла  ](https://youtu.be/sanq2X7Re8o?t=3803)
- [			01:05:02  Сравнение for keys, for (...in...) и for (...of...)](https://youtu.be/sanq2X7Re8o?t=3902)
- [			01:05:34  Результаты теста ](https://youtu.be/sanq2X7Re8o?t=3934)
- [			01:05:58  Сравнение шаблонных строк](https://youtu.be/sanq2X7Re8o?t=3958)
- [			01:06:12  Сравнение хождения цикла по функции map в ES6](https://youtu.be/sanq2X7Re8o?t=3972)
- [			01:07:18  Результаты теста ](https://youtu.be/sanq2X7Re8o?t=4038)
- [			01:07:56  Сравнение repeat и arrayJoin ](https://youtu.be/sanq2X7Re8o?t=4076)
- [			01:08:15  Результаты теста](https://youtu.be/sanq2X7Re8o?t=4095)
- [			01:08:26  Сравнение дублирования массива ](https://youtu.be/sanq2X7Re8o?t=4106)
- [			01:08:58  Результаты теста](https://youtu.be/sanq2X7Re8o?t=4138)
- [			01:09:43  Сравнение копирование набора данных  ](https://youtu.be/sanq2X7Re8o?t=4183)
- [			01:10:26  Результаты теста  ](https://youtu.be/sanq2X7Re8o?t=4226)
- [			01:10:47  Сравнение итерирования с помощью  forEarch и  for (...of...)](https://youtu.be/sanq2X7Re8o?t=4247)
- [			01:11:08  Результаты теста](https://youtu.be/sanq2X7Re8o?t=4268)
- [			01:11:31  Обобщение](https://youtu.be/sanq2X7Re8o?t=4291)
## [Слой доступа к данным, курсор, транзакция](https://youtu.be/CRcSWtWVvrA)
- [](https://youtu.be/CRcSWtWVvrA?t=0)
## [HTTP запросы в браузере и Node.js: XMLHttpRequest, fetch](https://youtu.be/wMMki2FEYGY)
- [](https://youtu.be/wMMki2FEYGY?t=0)
## [Метапрограммирование с примерами на JavaScript](https://youtu.be/Ed9onRv4G5Y)
- [](https://youtu.be/Ed9onRv4G5Y?t=0)
## [Тестирование: системное и интеграционное тестирование на JavaScript](https://youtu.be/OuKu_6H_6gE)
- [](https://youtu.be/OuKu_6H_6gE?t=0)
## [Отмена асинхронных операций, cancellable callback and Promise в JavaScript](https://youtu.be/T8fXlnqI4Ws)
- [](https://youtu.be/T8fXlnqI4Ws?t=0)
## [Асинхронная композиция функций на JavaScript](https://youtu.be/3ZCrMlMpOrM)
- [](https://youtu.be/3ZCrMlMpOrM?t=0)
## [Thenable и легковесный await в JavaScript](https://youtu.be/DXp__1VNIvI)
- [](https://youtu.be/DXp__1VNIvI?t=0)
## [Конкурентная асинхронная очередь на JavaScript](https://youtu.be/Lg46AH8wFvg)
- [](https://youtu.be/Lg46AH8wFvg?t=0)
## [Паттерн Revealing Constructor - открытый конструктор](https://youtu.be/leR5sXRkuJI)
- [](https://youtu.be/leR5sXRkuJI?t=0)
## [Модель акторов для параллельных вычислений](https://youtu.be/xp5MVKEqxY4)
- [](https://youtu.be/xp5MVKEqxY4?t=0)
## [Have Objects Failed? Или что не так с ООП?](https://youtu.be/4yO5OS0vPSw)
- [1:46 Присвоенные идеи ООП](https://youtu.be/4yO5OS0vPSw?t=106)
- [			11:47 Притянутые достоинства ООП](https://youtu.be/4yO5OS0vPSw?t=707)
- [			22:06 Проблемы ООП](https://youtu.be/4yO5OS0vPSw?t=1326)
- [			39:56 Как жить с ООП](https://youtu.be/4yO5OS0vPSw?t=2396)
- [			56:44 Подходящие области для ООП](https://youtu.be/4yO5OS0vPSw?t=3404)
- [			1:03:51 Неподходящие области для ООП](https://youtu.be/4yO5OS0vPSw?t=3831)
- [			1:11:30 Заключение](https://youtu.be/4yO5OS0vPSw?t=4290)
## [Интроспекция и рефлексия в JavaScript](https://youtu.be/yvW1PjUVeM0)
- [](https://youtu.be/yvW1PjUVeM0?t=0)
## [История развития языков программирования](https://youtu.be/qqz0VSaNxuw)
- [0:00:02 введение](https://youtu.be/qqz0VSaNxuw?t=2)
- [			0:00:57 карты для механических машин](https://youtu.be/qqz0VSaNxuw?t=57)
- [			0:01:50 карты для электронных машин](https://youtu.be/qqz0VSaNxuw?t=110)
- [			0:03:21 машинный код](https://youtu.be/qqz0VSaNxuw?t=201)
- [			0:04:05 Assembly language](https://youtu.be/qqz0VSaNxuw?t=245)
- [			0:06:14 Fortran](https://youtu.be/qqz0VSaNxuw?t=374)
- [			0:07:28 Basic](https://youtu.be/qqz0VSaNxuw?t=448)
- [			0:09:19 LISP](https://youtu.be/qqz0VSaNxuw?t=559)
- [			0:12:23 Algol 60](https://youtu.be/qqz0VSaNxuw?t=743)
- [			0:13:25 C](https://youtu.be/qqz0VSaNxuw?t=805)
- [			0:14:23 C++](https://youtu.be/qqz0VSaNxuw?t=863)
- [			0:15:13 Ada](https://youtu.be/qqz0VSaNxuw?t=913)
- [			0:16:08 dBase, FoxBase, Clipper](https://youtu.be/qqz0VSaNxuw?t=968)
- [			0:19:56 Haskell](https://youtu.be/qqz0VSaNxuw?t=1196)
- [			0:21:23 Python](https://youtu.be/qqz0VSaNxuw?t=1283)
- [			0:23:37 Java](https://youtu.be/qqz0VSaNxuw?t=1417)
- [			0:25:45 Delphi](https://youtu.be/qqz0VSaNxuw?t=1545)
- [			0:28:43 SQL](https://youtu.be/qqz0VSaNxuw?t=1723)
- [			0:30:43 PHP 0:41:17 стрелочку из плюсов взяли](https://youtu.be/qqz0VSaNxuw?t=1843)
- [			0:33:14 C#](https://youtu.be/qqz0VSaNxuw?t=1994)
- [			0:35:20 Go](https://youtu.be/qqz0VSaNxuw?t=2120)
- [			0:36:17 Rust](https://youtu.be/qqz0VSaNxuw?t=2177)
- [			0:37:30 TypeScript](https://youtu.be/qqz0VSaNxuw?t=2250)
- [			0:39:59 Swift](https://youtu.be/qqz0VSaNxuw?t=2399)
- [			0:40:19 Kotlin](https://youtu.be/qqz0VSaNxuw?t=2419)
- [			0:42:20 взаимовлияние языков](https://youtu.be/qqz0VSaNxuw?t=2540)
- [			ВОПРОСЫ](https://youtu.be/qqz0VSaNxuw?t=0)
- [			0:44:23 все ли языки используются сегодня](https://youtu.be/qqz0VSaNxuw?t=2663)
- [			0:49:35 производительность языков](https://youtu.be/qqz0VSaNxuw?t=2975)
- [			0:54:34 опциональная аннотация типов](https://youtu.be/qqz0VSaNxuw?t=3274)
- [			0:56:50 прогревание кода](https://youtu.be/qqz0VSaNxuw?t=3410)
- [			0:59:24 первые операционные системы](https://youtu.be/qqz0VSaNxuw?t=3564)
- [			1:00:44 ограничение по вложенности рекурсии](https://youtu.be/qqz0VSaNxuw?t=3644)
- [			1:02:53 абстрактное синтаксическое дерево](https://youtu.be/qqz0VSaNxuw?t=3773)
- [			1:04:52 машинный код и байт-код](https://youtu.be/qqz0VSaNxuw?t=3892)
- [			1:07:26 typescript быстрее javascript?](https://youtu.be/qqz0VSaNxuw?t=4046)
- [			1:11:45 goroutine на Go асинхронная?](https://youtu.be/qqz0VSaNxuw?t=4305)
- [			1:12:58 асинхронная функция в javascript](https://youtu.be/qqz0VSaNxuw?t=4378)
- [			1:15:23 строгая типизация влияет на скорость?](https://youtu.be/qqz0VSaNxuw?t=4523)
- [			1:16:13 выведение и проверка типов в IDE](https://youtu.be/qqz0VSaNxuw?t=4573)
## [Парадигмы программирования (обзор)](https://youtu.be/Yk1sxLVHfjs)
- [00:20 парадигма](https://youtu.be/Yk1sxLVHfjs?t=20)
- [			02:19 императивная программа: пошаговое исполнение на примере JavaScript](https://youtu.be/Yk1sxLVHfjs?t=139)
- [			03:22 пошаговое исполнение характерно для неструктурных ЯП: Assembly language, Basic](https://youtu.be/Yk1sxLVHfjs?t=202)
- [			05:08 структурная программа на Rust](https://youtu.be/Yk1sxLVHfjs?t=308)
- [			06:21 процедурный стиль на Python](https://youtu.be/Yk1sxLVHfjs?t=381)
- [			07:28 объектно-ориентированное программирование на примере JavaScript](https://youtu.be/Yk1sxLVHfjs?t=448)
- [			09:32 ООП хорош не для всякой задачи -- пример с пирожком](https://youtu.be/Yk1sxLVHfjs?t=572)
- [			13:28 прототипное программирование](https://youtu.be/Yk1sxLVHfjs?t=808)
- [			16:51 функциональное программирование](https://youtu.be/Yk1sxLVHfjs?t=1011)
- [			18:58 асинхронное программирование](https://youtu.be/Yk1sxLVHfjs?t=1138)
- [			22:48 реактивное программирование](https://youtu.be/Yk1sxLVHfjs?t=1368)
- [			26:04 событийно-ориентированное программирование (управляется потоками событий)](https://youtu.be/Yk1sxLVHfjs?t=1564)
- [			27:03 метапрограммирование](https://youtu.be/Yk1sxLVHfjs?t=1623)
- [			28:58 мультипарадигменное программирование](https://youtu.be/Yk1sxLVHfjs?t=1738)
- [			30:52 параллельное программирование](https://youtu.be/Yk1sxLVHfjs?t=1852)
- [			ВОПРОСЫ](https://youtu.be/Yk1sxLVHfjs?t=0)
- [			31:58 реактивность](https://youtu.be/Yk1sxLVHfjs?t=1918)
- [			33:29 функции 1 класса](https://youtu.be/Yk1sxLVHfjs?t=2009)
- [			34:55 геттеры и сеттеры](https://youtu.be/Yk1sxLVHfjs?t=2095)
- [			37:37 смешивание стилей](https://youtu.be/Yk1sxLVHfjs?t=2257)
- [			38:07 если хочется писать в чистом ООП](https://youtu.be/Yk1sxLVHfjs?t=2287)
- [			39:43 объект, класс, коллекция -- разница](https://youtu.be/Yk1sxLVHfjs?t=2383)
- [			47:27 где хранятся классы](https://youtu.be/Yk1sxLVHfjs?t=2847)
- [			47:54 у каждой парадигмы свои шаблоны программирования](https://youtu.be/Yk1sxLVHfjs?t=2874)
- [			48:52 когда используется функциональное программирование](https://youtu.be/Yk1sxLVHfjs?t=2932)
## [Примеси, обертки, декораторы, мемоизация](https://youtu.be/2h9syXN5wO0)
- [---------------------------------------------------- Функции-обертки  (Wrappers) ------------------------------------------------](https://youtu.be/2h9syXN5wO0?t=0)
- [			00:00:00  Синхронная функция-обертка  ](https://youtu.be/2h9syXN5wO0?t=0)
- [			00:02:55  Синхронная универсальная функция-обертка   ](https://youtu.be/2h9syXN5wO0?t=175)
- [			00:08:28  Асинхронная универсальная функция-обертка  ](https://youtu.be/2h9syXN5wO0?t=508)
- [			00:15:50  Синхронная функция-обертка, которая добавляет поведение (timeout)](https://youtu.be/2h9syXN5wO0?t=950)
- [			00:22:45  Асинхронная функция-обертка, которая добавляет поведение (timeout)](https://youtu.be/2h9syXN5wO0?t=1365)
- [			00:25:38  Функция-обертка, которая ограничивает вызов функции до одного вызова (once) ](https://youtu.be/2h9syXN5wO0?t=1538)
- [			00:27:36  Функция-обертка, которая ограничивает вызов функции до  n-го вызова (limit)](https://youtu.be/2h9syXN5wO0?t=1656)
- [			00:29:50  Функция-обертка, которая отменяет вызов функции (cancel)](https://youtu.be/2h9syXN5wO0?t=1790)
- [			00:32:29  Функция-обертка с методами timeout, limit, cancel](https://youtu.be/2h9syXN5wO0?t=1949)
- [			00:39:03  Функция-обертка с методами timeout, limit, cancel (оптимизированная)](https://youtu.be/2h9syXN5wO0?t=2343)
- [			00:42:28  Функция-обертка, которая ограничивает один вызов за 200 мс (throttle)](https://youtu.be/2h9syXN5wO0?t=2548)
- [			-----------------------------------------------------------  Примеси (Mixins) ---------------------------------------------------------------](https://youtu.be/2h9syXN5wO0?t=0)
- [			00:45:47  Примесь поля через точку  ](https://youtu.be/2h9syXN5wO0?t=2747)
- [			00:51:35  Примесь поля через  функцию extend](https://youtu.be/2h9syXN5wO0?t=3095)
- [			00:57:35  Примесь поля через object.assign( )](https://youtu.be/2h9syXN5wO0?t=3455)
- [			00:59:18  Примесь поведения    ](https://youtu.be/2h9syXN5wO0?t=3558)
- [			01:02:23  Примесь изменения класса](https://youtu.be/2h9syXN5wO0?t=3743)
- [			---------------------------------------------------  Мемоизация  (Memoization)  ---------------------------------------------------](https://youtu.be/2h9syXN5wO0?t=0)
- [			01:06:50  Определение](https://youtu.be/2h9syXN5wO0?t=4010)
- [			01:07:30  Реализация простой мемоизации       ](https://youtu.be/2h9syXN5wO0?t=4050)
- [			01:14:43  Реализация простой мемоизации с проверкой скорости  ](https://youtu.be/2h9syXN5wO0?t=4483)
- [			01:20:43  Удаление накопленного кэша   ](https://youtu.be/2h9syXN5wO0?t=4843)
- [			01:25:35  Асинхронная мемоизация ](https://youtu.be/2h9syXN5wO0?t=5135)
- [			01:31:10  Преобразование аргументов и ключей в  hash-функцию](https://youtu.be/2h9syXN5wO0?t=5470)
- [			01:33:32  Реализация сложной мемоизации](https://youtu.be/2h9syXN5wO0?t=5612)
## [Ответы на вопросы по курсу "Основы программирования" 2019-2020](https://youtu.be/TY6nDW7aYys)
- [](https://youtu.be/TY6nDW7aYys?t=0)
## [Антипаттерны процедурного программирования](https://youtu.be/cTv7V22mkwE)
- [](https://youtu.be/cTv7V22mkwE?t=0)
## [Семинар: выполнение лабораторных работ на JavaSript по курсу "Основы программирования"](https://youtu.be/ikUOyFPzdJw)
- [](https://youtu.be/ikUOyFPzdJw?t=0)
## [Массивы в JavaScript (методы Array)](https://youtu.be/D1kfYBkX9FE)
- [00:00 Конструкция массива](https://youtu.be/D1kfYBkX9FE?t=0)
- [			09:58 Метод concat](https://youtu.be/D1kfYBkX9FE?t=598)
- [			11:00 Методы every и some  ](https://youtu.be/D1kfYBkX9FE?t=660)
- [			13:00 Метод filter ](https://youtu.be/D1kfYBkX9FE?t=780)
- [			13:29 Методы  find и findIndex](https://youtu.be/D1kfYBkX9FE?t=809)
- [			14:30 Метод flat ](https://youtu.be/D1kfYBkX9FE?t=870)
- [			17:08 Метод includes ](https://youtu.be/D1kfYBkX9FE?t=1028)
- [			17:32 Метод indexOf и lastIndexOf](https://youtu.be/D1kfYBkX9FE?t=1052)
- [			18:35 Метод join](https://youtu.be/D1kfYBkX9FE?t=1115)
- [			18:58 Метод reverse](https://youtu.be/D1kfYBkX9FE?t=1138)
- [			19:29 Метод slice](https://youtu.be/D1kfYBkX9FE?t=1169)
- [			21:49 Метод splice](https://youtu.be/D1kfYBkX9FE?t=1309)
- [			23:27 Методы reduce и reduceRight](https://youtu.be/D1kfYBkX9FE?t=1407)
## [Code Review: как это и зачем](https://youtu.be/EKL6NiIQ6ZU)
- [](https://youtu.be/EKL6NiIQ6ZU?t=0)
## [Семинар: Code Review, ответы на вопросы](https://youtu.be/AgH4OAKbmkM)
- [](https://youtu.be/AgH4OAKbmkM?t=0)
## [Мономорфный и полиморфный код, инлайн-кэш, скрытые классы в JavaScript](https://youtu.be/9JUY3prnCQ4)
- [](https://youtu.be/9JUY3prnCQ4?t=0)
## [Ассоциация, агрегация и композиция объектов в JavaScript](https://youtu.be/tOIcBrzezK0)
- [](https://youtu.be/tOIcBrzezK0?t=0)
## [Рефакторинг: причины, цели, техники и процесс](https://youtu.be/z73wmpdweQ4)
- [](https://youtu.be/z73wmpdweQ4?t=0)
## [Принцип подстановки Барбары Лисков](https://youtu.be/RbhYxygxroc)
- [](https://youtu.be/RbhYxygxroc?t=0)
## [Композиция функций (pipe, compose) в JavaScript](https://youtu.be/xS9FicVrOTI)
- [](https://youtu.be/xS9FicVrOTI?t=0)
## [Примеси в JavaScript: mixin, extend, Object.assign, class λ-mixin](https://youtu.be/NZMrJ2adEyY)
- [](https://youtu.be/NZMrJ2adEyY?t=0)
## [Прототипное программирование и прототипное наследование в JavaScript](https://youtu.be/SzaXTW2qcJE)
- [](https://youtu.be/SzaXTW2qcJE?t=0)
## [Мемоизация функций: memoize в JavaScript](https://youtu.be/H6S8QJo2Qxg)
- [](https://youtu.be/H6S8QJo2Qxg?t=0)
## [Функции-обертки: Wrappers в JavaScript](https://youtu.be/En7pWi2fSzs)
- [](https://youtu.be/En7pWi2fSzs?t=0)
## [Новое в JavaScript: ES.Next, ECMAScript 2020, ES11, ES10, ES9, ES8, ES7, ES6, ES2020, ES2019](https://youtu.be/fUjHLj8bq_Y)
- [00:00  ECMA Script versions](https://youtu.be/fUjHLj8bq_Y?t=0)
- [			09:40  Array.proptotype.includes ](https://youtu.be/fUjHLj8bq_Y?t=580)
- [			10:55  Array.proptotype.flat   ](https://youtu.be/fUjHLj8bq_Y?t=655)
- [			11:36  Array.proptotype.flatMap](https://youtu.be/fUjHLj8bq_Y?t=696)
- [			12:20  Array.proptotype.sort](https://youtu.be/fUjHLj8bq_Y?t=740)
- [			14:24  Object.values ](https://youtu.be/fUjHLj8bq_Y?t=864)
- [			15:06  Object.keys ](https://youtu.be/fUjHLj8bq_Y?t=906)
- [			15:15  Object.entries ](https://youtu.be/fUjHLj8bq_Y?t=915)
- [			15:49  Object.fromEntries ](https://youtu.be/fUjHLj8bq_Y?t=949)
- [			16:36  String.proptotype.padStart / String.proptotype.padEnd ](https://youtu.be/fUjHLj8bq_Y?t=996)
- [			17:02  String.proptotype.trimStart / String.proptotype.trimEnd](https://youtu.be/fUjHLj8bq_Y?t=1022)
- [			17:18  Operator  rest  ](https://youtu.be/fUjHLj8bq_Y?t=1038)
- [			19:38  Operator spread](https://youtu.be/fUjHLj8bq_Y?t=1178)
- [			21:34  Operator exponentiation x ** y](https://youtu.be/fUjHLj8bq_Y?t=1294)
- [			22:35  Operator optional chaining  ?.](https://youtu.be/fUjHLj8bq_Y?t=1355)
- [			24:22  Asynchronous function: async / await  ](https://youtu.be/fUjHLj8bq_Y?t=1462)
- [			26:34  Trailing Commas  ](https://youtu.be/fUjHLj8bq_Y?t=1594)
- [			28:00  Asynchronous iterable contract: for-await](https://youtu.be/fUjHLj8bq_Y?t=1680)
- [			29:51  Try...catch  ](https://youtu.be/fUjHLj8bq_Y?t=1791)
- [			30:21  Function.prototype.toString ](https://youtu.be/fUjHLj8bq_Y?t=1821)
- [			30:58  Symbol.prototype.description ](https://youtu.be/fUjHLj8bq_Y?t=1858)
- [			32:11  Promise.finaly   ](https://youtu.be/fUjHLj8bq_Y?t=1931)
- [			33:22  Promise.allSettled  ](https://youtu.be/fUjHLj8bq_Y?t=2002)
- [			36:18  More features](https://youtu.be/fUjHLj8bq_Y?t=2178)
## [Вступительная лекция по инженерии программного обеспечения (КПИ 1 курс) 2021-09-01](https://youtu.be/vWi6KyG078g)
- [](https://youtu.be/vWi6KyG078g?t=0)
## [Автоматное программирование c примерами на JavaScript](https://youtu.be/mxz7_zcip0c)
- [](https://youtu.be/mxz7_zcip0c?t=0)
## [Контрактное программирование с примерами на JavaScript и Node.js](https://youtu.be/K5_kSUvbGEQ)
- [](https://youtu.be/K5_kSUvbGEQ?t=0)
## [JavaScript - Практические задачи #1: Пример исправления, лайвкодинг, оптимизация и рефакторинг](https://youtu.be/CRmjViLEE9E)
- [](https://youtu.be/CRmjViLEE9E?t=0)
## [JavaScript и Node.js: Добавь в Github личную карту знаний](https://youtu.be/gDUGZsw2N2g)
- [](https://youtu.be/gDUGZsw2N2g?t=0)
